home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / alpha.arc / SYS5_IO.C < prev    next >
C/C++ Source or Header  |  1988-07-26  |  8KB  |  390 lines
  1. /* OS- and machine-dependent stuff for SYS5 */
  2.  
  3. /*
  4.     FILE: UNIX.io.c
  5.     
  6.     Routines:
  7.         ioinit()
  8.         iostop()
  9.         asy_init()
  10.         asy_stop()
  11.         asy_speed()
  12.         asy_output()
  13.         asy_recv()
  14.         dir()
  15.     Written or converted by Mikel Matthews, N9DVG
  16.     SYS5 added by Jere Sandidge, K4FUM
  17.     
  18.     If you want to use the select code, define SELECT in the makefile or
  19.     in this file.
  20. */
  21.  
  22. #include <stdio.h>
  23. #include <sys/types.h>
  24. #include <termio.h>
  25. #include <signal.h>
  26. #include <sys/file.h>
  27. #include <sys/dir.h>
  28. #include <time.h>
  29. #include <fcntl.h>
  30. #include "global.h"
  31. #include "mbuf.h"
  32. #include "internet.h"
  33. #include "iface.h"
  34. #include "unix.h"
  35. #include "cmdparse.h"
  36.  
  37. struct asy asy[ASY_MAX];
  38.  
  39. struct interface *ifaces;
  40.  
  41. struct termio mysavetty, savecon;
  42. int    IORser[ASY_MAX];
  43. /*
  44. int    IOWser;
  45. */
  46. char *ttbuf;
  47.  
  48.  
  49. /* Called at startup time to set up console I/O, memory heap */
  50. ioinit()
  51. {
  52.     struct termio ttybuf;
  53.     extern int iostop();
  54.     register unsigned i;
  55.     unsigned grabcore();
  56.     char *malloc();
  57.  
  58.     /* Interrupts use a special stack deep in data space.
  59.      * Calls to sbrk() (invoked by malloc when it needs more memory
  60.      * from the system) at interrupt time will fail because sbrk()
  61.      * will think that the stack has overwritten the heap. So
  62.      * grab all the memory we can now for the heap so that malloc
  63.      * won't have to call sbrk and alloc_mbuf() won't fail unnecessarily
  64.      * at interrupt time.
  65.      */
  66.     (void)signal(SIGHUP, iostop);
  67.     (void)signal(SIGINT, iostop);
  68.     (void)signal(SIGQUIT, iostop);
  69.     (void)signal(SIGTERM, iostop);
  70.     ioctl(0, TCGETA, &ttybuf);
  71.     savecon = ttybuf;
  72.     ttybuf.c_lflag &= ~ECHO;
  73.     ttybuf.c_lflag &= ~ICANON;
  74.     ttybuf.c_cc[VTIME] = '\01';
  75.     ttybuf.c_cc[VMIN] = '\0';
  76.     ioctl(0, TCSETA, &ttybuf);
  77. }
  78. /* Called just before exiting to restore console state */
  79. iostop()
  80. {
  81.     setbuf(stdout,NULLCHAR);
  82.     while(ifaces != NULLIF){
  83.         if(ifaces->stop != NULLFP)
  84.             (*ifaces->stop)(ifaces->dev);
  85.         ifaces = ifaces->next;
  86.     }
  87.     ioctl(0, TCSETA, &savecon);
  88.     exit(0);
  89. }
  90.  
  91. /* Initialize asynch port "dev" */
  92. int slipisopen;
  93. int
  94. asy_init(dev,arg1,arg2,bufsize)
  95. int16 dev;
  96. char *arg1,*arg2;
  97. unsigned bufsize;
  98. {
  99.     register struct asy *ap;
  100.     register struct interface *if_asy;
  101.     extern struct interface *ifaces;
  102.     struct termio    mytty, sgttyb;
  103.     ap = &asy[dev];
  104.     /*
  105.     printf("asy_init: called\n");
  106.     */
  107.  
  108.     if ( ap == NULL)
  109.     {
  110.         return(-1);
  111.     }
  112.     ap->tty = malloc(strlen(arg2)+1);
  113.     strcpy(ap->tty, arg2);
  114.  
  115.     printf("asy_init: tty name = %s\n", ap->tty);
  116.     
  117.  
  118.     if ((IORser[dev] = open (ap->tty, (O_RDWR), 0)) < 0)
  119.     {
  120.         perror ("Could not open device IORser");
  121.         return (-1);
  122.     }
  123. /*
  124.     if ((IOWser = open (ap->tty, (O_WRONLY), 0)) < 0)
  125.     {
  126.         perror ("Could not open device IOWser");
  127.         return (-1);
  128.     }
  129. */
  130.  /* 
  131.   * get the stty structure and save it 
  132.   */
  133.  
  134.     if (ioctl(IORser[dev], TCGETA, &mysavetty) < 0)
  135.     {
  136.         perror ("ioctl failed on device");
  137.         return (-1);
  138.     }
  139.  /* 
  140.   * copy over the structure 
  141.   */
  142.  
  143.     sgttyb = mysavetty;
  144.     sgttyb.c_iflag = (IGNBRK | IGNPAR);
  145.     sgttyb.c_oflag = 0;
  146.     sgttyb.c_lflag = 0;
  147.     sgttyb.c_cflag = (B9600 | CS8 | CREAD);
  148.     sgttyb.c_cc[VTIME] = '\05';
  149.     sgttyb.c_cc[VMIN] = '\0';
  150.     if (ioctl(IORser[dev], TCSETAF, &sgttyb) < 0)
  151.     {
  152.         perror ("ioctl could not set parameters for IORser");
  153.         return (-1);
  154.     }
  155. /*
  156.     if (ioctl (IOWser, TIOCSETP, &sgttyb) < 0)
  157.     {
  158.         perror ("ioctl could not set parameters for IOWser");
  159.         return (-1);
  160.     }
  161. */
  162.  
  163.     return (0);
  164. }
  165.  
  166. int
  167. asy_stop(dev)
  168. int dev;
  169. {
  170. }
  171.  
  172. /* Set asynch line speed */
  173. int
  174. asy_speed(dev,speed)
  175. int dev;
  176. int speed;
  177. {
  178.     register int divisor;
  179.     struct termio sgttyb;
  180.     int i_state;
  181.  
  182.     if(speed == 0 || dev >= nasy)
  183.         return(-1);
  184.     /*
  185.     printf("asy_speed: Setting speed for device %d to %d\n",dev, speed);
  186.     */
  187.     asy[dev].speed = speed;
  188.  
  189.     if (ioctl(IORser[dev], TCGETA, &sgttyb) < 0)
  190.     {
  191.         perror ("ioctl could not set parameters");
  192.         return (-1);
  193.     }
  194.     sgttyb.c_cflag &= ~CBAUD;
  195.     switch(speed)
  196.     {
  197.         case 0:
  198.             sgttyb.c_cflag |= B0;
  199.             break;
  200.         case 50:
  201.             sgttyb.c_cflag |= B50;
  202.             break;
  203.         case 75:
  204.             sgttyb.c_cflag |= B75;
  205.             break;
  206.         case 110:
  207.             sgttyb.c_cflag |= B110;
  208.             break;
  209.         case 134:
  210.             sgttyb.c_cflag |= B134;
  211.             break;
  212.         case 150:
  213.             sgttyb.c_cflag |= B150;
  214.             break;
  215.         case 200:
  216.             sgttyb.c_cflag |= B200;
  217.             break;
  218.         case 300:
  219.             sgttyb.c_cflag |= B300;
  220.             break;
  221.         case 600:
  222.             sgttyb.c_cflag |= B600;
  223.             break;
  224.         case 1200:
  225.             sgttyb.c_cflag |= B1200;
  226.             break;
  227.         case 1800:
  228.             sgttyb.c_cflag |= B1800;
  229.             break;
  230.         case 2400:
  231.             sgttyb.c_cflag |= B2400;
  232.             break;
  233.         case 4800:
  234.             sgttyb.c_cflag |= B4800;
  235.             break;
  236.         case 9600:
  237.             sgttyb.c_cflag |= B9600;
  238.             break;
  239.         /*
  240.         case EXTA:
  241.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = EXTA;
  242.             break;
  243.         case EXTB:
  244.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = EXTB;
  245.             break;
  246.         */
  247.         default:
  248.             printf("asy_speed: Unknown speed (%d)\n", speed);
  249.             break;
  250.     }
  251. /*
  252.     printf("speed = %d\n", sgttyb.sg_ispeed);
  253.     */
  254.     if (ioctl(IORser[dev], TCSETA, &sgttyb) < 0)
  255.     {
  256.         perror ("ioctl could not set parameters for IORser");
  257.         return (-1);
  258.     }
  259. /*
  260.     if (ioctl (IOWser, TIOCSETP, &sgttyb) < 0)
  261.     {
  262.         perror ("ioctl could not set parameters for IOWser");
  263.         return (-1);
  264.     }
  265. */
  266.     return(0);
  267. }
  268. /* Send a buffer to serial transmitter */
  269. asy_output(dev,buf,cnt)
  270. unsigned dev;
  271. char *buf;
  272. unsigned short cnt;
  273. {
  274.     /*
  275.     printf("asy_output called. dev = %x, cnt = %d\n", dev, cnt);
  276.     printf("buf=%s\n", buf);
  277.     fflush(stdout);
  278.     */
  279.     
  280.     if(dev >= nasy)
  281.         return(-1);
  282.     if ( write(IORser[dev], buf, cnt) < cnt)
  283.     {
  284.         perror("asy_output");
  285.         printf("asy_output: error in writing to device %d\n", dev);
  286.         return(-1);
  287.     }
  288.     return(0);
  289. }
  290. /* Receive characters from asynch line
  291.  * Returns count of characters read
  292.  */
  293. unsigned
  294. asy_recv(dev,buf,cnt)
  295. int dev;
  296. char *buf;
  297. unsigned cnt;
  298. {
  299.     unsigned tot,n;
  300.     int r;
  301.     long amount;
  302.  
  303. #ifdef SELECT
  304.     int    mask;
  305.     int    writemask;
  306.     int    ok;
  307.     struct timeval timeout;
  308.     timeout.tv_sec = 0;
  309.     timeout.tv_usec = 35;
  310.     mask = (1<<IORser[dev]);
  311.     writemask = (1<<IORser[dev]);
  312.     ok = 0;
  313.     tot = 0;
  314.     ok = select(mask, &mask, 0, 0, &timeout);
  315.     if ( mask & (1<<IORser[dev]))
  316.     {
  317.         tot = read(IORser[dev], buf, cnt);
  318.     }
  319.     return (tot);
  320. #else
  321.     tot = 0;
  322.     amount = 0;
  323.     r = read(IORser[dev], buf, cnt);
  324.     if (r == -1) {
  325.         perror("asy_output");
  326.         printf("asy_output: error in writing to device %d\n", dev);
  327.         return(0);
  328.     }
  329.     tot = (unsigned int) r;
  330.     return (tot);
  331. #endif SELECT
  332. }
  333. /* Create a directory listing in a temp file and return the resulting file
  334.  * descriptor. If full == 1, give a full listing; else return just a list
  335.  * of names.
  336.  *
  337.  * This function is very dependent on the workings of Aztec standard I/O;
  338.  * it uses their mechanism for generating and deleting temporary files.
  339.  */
  340. FILE *
  341. dir(path,full)
  342. char *path;
  343. int full;
  344. {
  345.     FILE *fp;
  346.     char cmd[1024];
  347.     char filename[13];        /* instance of filename */
  348.     char name[L_tmpnam], *tmpnam(), *malloc();
  349.     tmpnam(name);
  350.  
  351.     if ( path[0] == '\0' )
  352.     {
  353.         path = ".";
  354.         /*
  355.         printf("Path = %s\n", path);
  356.         */
  357.     }
  358.     /*
  359.     printf("DIR: tempname = %s, path = %s\n",name, path);
  360.     */
  361.  
  362.     if(full){
  363.         sprintf(cmd,"ls -l %s > %s",path,name);
  364.         system(cmd);
  365.     } else {
  366.         sprintf(cmd, "ls %s > %s", path, name);
  367.         system(cmd);
  368.     }
  369.     if( (fp = fopen(name,"r")) == NULL)
  370.     {
  371.         perror("fopen");
  372.     }
  373.     /* Set up the magic cookies inside the file structure so that the
  374.      * temporary file gets deleted later when the file is closed
  375.      */
  376.     (void)unlink(name);
  377.     return (fp);
  378. }
  379. asy_ioctl(interface, argc, argv)
  380. struct interface *interface;
  381. int    argc;
  382. char    *argv[];
  383. {
  384.     if (argc < 1) {
  385.         printf("%d\r\n", asy[interface->dev].speed);
  386.         return 0;
  387.     }
  388.     return asy_speed(interface->dev, atoi(argv[0]));
  389. }
  390.